#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAX = 3e5 + 5; // 最大节点数

vector<int> graph[MAX];              // 图的邻接表表示
int edge_u[MAX], edge_v[MAX];        // 存储边的两个端点
int dfn[MAX], low[MAX], parent[MAX]; // DFS序、子树最大DFS序、父节点
int dfs_order = 0, total_weight = 0; // DFS计数器、总权重

// 树状数组实现
struct BitTree {
  ll data[MAX]; // 存储数据

  // 计算最低有效位
  static int lowbit(int x) { return x & -x; }

  // 更新位置pos的值，增加val
  void update(int pos, int val) {
    for (; pos < MAX; pos += lowbit(pos))
      data[pos] += val;
  }

  // 查询前缀和[1..pos]
  ll query(int pos) {
    ll res = 0;
    for (; pos > 0; pos -= lowbit(pos))
      res += data[pos];
    return res;
  }
} bit;

/*

low数组的含义和工作原理：

核心概念：

dfn[u]：节点u被DFS访问时的顺序编号（时间戳）
low[u]：以u为根的子树中所有节点的最大dfn值
具体作用：

在树结构中，DFS遍历会为每个子树生成一段连续的dfn区间
low[u]标记了这个连续区间的右端点
例如：子树u的范围是[dfn[u], low[u]]

*/
// DFS遍历树，计算DFS序和子树范围
void dfs(int u, int father) {
  parent[u] = father;            // 记录父节点
  dfn[u] = low[u] = ++dfs_order; // 设置DFS序和初始low值
  for (int v : graph[u]) {
    if (v == father)
      continue; // 跳过父节点
    dfs(v, u);

    // 这里的low实际上是"子树最大dfn"（subtree max dfn）
    // 它表示的是以u为根的子树中所有节点的dfn最大值 
    low[u] =  max(low[u], low[v]); // 更新子树最大DFS序
  }
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int n;
  cin >> n;

  // 构建树结构
  for (int i = 1; i < n; ++i) {
    cin >> edge_u[i] >> edge_v[i];
    graph[edge_u[i]].push_back(edge_v[i]);
    graph[edge_v[i]].push_back(edge_u[i]);
  }

  dfs(1, 0); // 从根节点1开始DFS

  // 初始化树状数组，每个节点初始权重为1
  for (int i = 1; i <= n; ++i)
    bit.update(dfn[i], 1);
  total_weight = n; // 初始总权重

  int q;
  cin >> q;
  while (q--) {
    int op;
    cin >> op;

    if (op == 1) { // 更新操作
      int node, weight;
      cin >> node >> weight;
      total_weight += weight;        // 更新总权重
      bit.update(dfn[node], weight); // 更新节点权重
    } else {                         // 查询操作
      int edge_idx;
      cin >> edge_idx;

      // 确定父子关系
      int u = edge_u[edge_idx], v = edge_v[edge_idx];
      if (parent[u] != v)
        swap(u, v);

      // 计算子树权重和
      ll subtree_sum = bit.query(low[u]) - bit.query(dfn[u] - 1);
      // 输出平衡值
      cout << abs(total_weight - 2 * subtree_sum) << '\n';
    }
  }
  return 0;
}